home *** CD-ROM | disk | FTP | other *** search
/ System Booster / System Booster.iso / Archives / HardwareProjects / atomuhr12.lha / AtomUhr / AtomUhr.c < prev    next >
Encoding:
C/C++ Source or Header  |  1995-12-30  |  24.1 KB  |  778 lines
  1. /*
  2.            Dieses Source wurde mit der Programmier-Umgebung CSH V4.15
  3.                    von M.Bühler und S.Glükler geschrieben.
  4.  
  5.   #########################################################################
  6.  
  7.    Programmname : AtomUhr
  8.    Version      : 1.2
  9.    Autor        : S. Glükler
  10.    Datum        : 30.12.95
  11.    Beschreibung : Einlesen und Dekodieren des DCF77 Empfaenger-Moduls
  12.  
  13.    Compilieren mit Aztec V5.2d :
  14.  
  15.               cc AtomUhr -md -mc -w0w -wn -wu -wr -wp -pb -sa -sb -sf -sm
  16.               ln AtomUhr +q -lcl
  17.  
  18.   #########################################################################
  19.  
  20. */
  21.  
  22. #include <stdio.h>
  23. #include <stdlib.h>
  24. #include <string.h>
  25. #include <workbench/startup.h>
  26. #include <hardware/custom.h>
  27. #include <hardware/cia.h>
  28. #include <clib/dos_protos.h>
  29. #include <clib/exec_protos.h>
  30. #include <clib/icon_protos.h>
  31. #include <clib/graphics_protos.h>
  32. #include <clib/intuition_protos.h>
  33. #include <clib/alib_protos.h>
  34. #include <pragma/dos_lib.h>
  35. #include <pragma/exec_lib.h>
  36. #include <pragma/icon_lib.h>
  37. #include <pragma/graphics_lib.h>
  38. #include <pragma/intuition_lib.h>
  39.  
  40.  
  41. #define WINDOW_GROESSE_X    310    /* Window Groesse-X            */
  42. #define WINDOW_GROESSE_Y    23    /* Window Groesse-Y            */
  43.  
  44. #define DEBUG_WINDOW_GROESSE_Y    28    /* Window Groesse-Y bei Debug-Mode    */
  45. #define DEBUG_OFFSET_X        5    /* X-Offset der Grafik bei Debug-Mode    */
  46. #define DEBUG_OFFSET_Y        21    /* Y-Offset der Grafik bei Debug-Mode    */
  47. #define DEBUG_GROESSE_Y        3    /* Y-Groesse der Grafik bei Debug-Mode    */
  48.  
  49. #define DEFAULT_DEBUG        0    /* Debug-Mode nicht aktiv        */
  50. #define DEFAULT_PORT        0    /* Welcher Pin bei Joystickport        */
  51. #define DEFAULT_FENSTER_X    30    /* Window X-Kordinate            */
  52. #define DEFAULT_FENSTER_Y    15    /* Window Y-Kordinate            */
  53. #define DEFAULT_AUSGABE        1    /* Window-Ausgabe aktiv            */
  54. #define DEFAULT_PRIORITAET    100    /* Prioritaet des Programms        */
  55. #define DEFAULT_MAX_SUCHEZEIT    600    /* Maximale Suchezeit in [s]        */
  56. #define DEFAULT_DOS_BEFEHL    ""    /* Dos-Ausfuehrung nach dem Erkennen    */
  57.  
  58. /* Makro zum setzen und anzeigen des Blockstatus */
  59. #define SET_BLOCKSTATUS(blkstatus)    blockstatus=blkstatus; WriteText(blockstatus_text[blockstatus],3);
  60.  
  61. /* Makro zum Anzeigen und warten bei einem Fehler */
  62. #define SET_ERRORTEXT(errnr)        WriteText(error_text[errnr],2); Delay(120);
  63.  
  64. /* Puls-Zeiten */
  65. #define TIMER_DELAY        20    /* Abtastzeit des Ports [ms]        */
  66. #define TIMER_SYNCHLEN        1600    /* Minimale Synchronationszeit [ms]    */
  67. #define TIMER_PULS_BIT0_MIN    20    /* Minimale Pulsdauer fuer 0-Bit [ms]    */
  68. #define TIMER_PULS_BIT0_MAX    120    /* Maximale Plusdauer fuer 0-Bit [ms]    */
  69. #define TIMER_PULS_BIT1_MIN    140    /* Minimale Plusdauer fuer 1-Bit [ms]    */
  70. #define TIMER_PULS_BIT1_MAX    240    /* Maximale Plusdauer fuer 1-Bit [ms]    */
  71.  
  72. /* Blockstatus */
  73. #define BLOCKSTATUS_VORBEREITUNG 0    /* Vorbereitung             */
  74. #define BLOCKSTATUS_SUCHESTART     1    /* Startpunkt suchen der Zeit        */
  75. #define BLOCKSTATUS_TIME     2    /* Zeit-Block                */
  76. #define BLOCKSTATUS_TIMEOK     3    /* Zeit-Block fertig uebertragen    */
  77. #define BLOCKSTATUS_EXIT     4    /* Programm Exit            */
  78.  
  79. unsigned char *blockstatus_text[] =
  80. {
  81.     "Vorbereitung",            /* Vorbereitung                */
  82.     "Suche Zeitblock-Anfang ...",    /* Synchsuche                */
  83.     "Empfange Zeitblock ...",    /* Zeit-Block empfang            */
  84.     "Zeitblock fertig",        /* Zeit-Block ok            */
  85.     "Progamm-Exit"            /* Programm Exit            */
  86. };
  87.  
  88. struct bitcodierung
  89. {
  90.     unsigned char  AnzahlBits;    /* Total Anzahl Bits            */
  91.     unsigned char  AktBit;        /* Akt uebertagenes Bit            */
  92.     unsigned short ZahlenWert;    /* Akt Zahlenwert            */
  93.     unsigned char  ParityWert;    /* Paritywert dieses Blockes        */
  94. };
  95.  
  96. /* Bitbloecke */
  97. #define ANZAHL_BITBLOECKE    15    /* Anzahl Bitbloecke bei der Codierung    */
  98.  
  99. struct bitcodierung BitCodierung[ANZAHL_BITBLOECKE] =
  100. {
  101.     /* Anzahl Bits */
  102.         21,    0,    0,    0,    /* 0.  Sonstiges        */
  103.         4,    0,    0,    0,    /* 1.  Minuten Low-Byte        */
  104.         3,    0,    0,    0,    /* 2.  Minuten High-Byte    */
  105.         1,    0,    0,    0,    /* 3.  Parity 1            */
  106.         4,    0,    0,    0,    /* 4.  Stunden Low-Byte        */
  107.         2,    0,    0,    0,    /* 5.  Stunden High-Byte    */
  108.         1,    0,    0,    0,    /* 6.  Parity 2            */
  109.         4,    0,    0,    0,    /* 7.  Tag Low-Byte        */
  110.         2,    0,    0,    0,    /* 8.  Tag High-Byte        */
  111.         3,    0,    0,    0,    /* 9.  Wochentag         */
  112.         4,    0,    0,    0,    /* 10. Monat Low-Byte        */
  113.         1,    0,    0,    0,    /* 11. Monat High-Byte        */
  114.         4,    0,    0,    0,    /* 12. Jahr Low-Byte        */
  115.         4,    0,    0,    0,    /* 13. Jahr High-Byte        */
  116.         1,    0,    0,    0    /* 14. Parity 3            */
  117. };
  118.  
  119. /* Bitblocknummern */
  120. #define BITBLOCK_MIN_LOW    1    /* Blocknummer fuer Minuten Low-Byte    */
  121. #define BITBLOCK_MIN_HIGH    2    /* Blocknummer fuer Minuten High-Byte    */
  122. #define BITBLOCK_PARITY_1    3    /* Blocknummer fuer Paritaet 1        */
  123. #define BITBLOCK_STD_LOW    4    /* Blocknummer fuer Stunden Low-Byte    */
  124. #define BITBLOCK_STD_HIGH    5    /* Blocknummer fuer Stunden High-Byte    */
  125. #define BITBLOCK_PARITY_2    6    /* Blocknummer fuer Paritaet 2        */
  126. #define BITBLOCK_TAG_LOW    7    /* Blocknummer fuer Tag Low-Byte    */
  127. #define BITBLOCK_TAG_HIGH    8    /* Blocknummer fuer Tag High-Byte    */
  128. #define BITBLOCK_WOCHENTAG    9    /* Blocknummer fuer Wochentag        */
  129. #define BITBLOCK_MONAT_LOW    10    /* Blocknummer fuer Monat Low-Byte    */
  130. #define BITBLOCK_MONAT_HIGH    11    /* Blocknummer fuer Monat High-Byte    */
  131. #define BITBLOCK_JAHR_LOW    12    /* Blocknummer fuer Jahr Low-Byte    */
  132. #define BITBLOCK_JAHR_HIGH    13    /* Blocknummer fuer Jahr High-Byte    */
  133. #define BITBLOCK_PARITY_3    14    /* Blocknummer fuer Paritaet 3        */
  134.  
  135. /* Error-Codes */
  136. #define ERROR_NONE        0    /* Kein Fehler                */
  137. #define ERROR_NO_LIBRARYS    1    /* Kann Library nicht oeffnen        */
  138. #define ERROR_NO_WINDOW        2    /* Kann Window nicht oeffnen        */
  139. #define ERROR_NO_TIMERPORT    3    /* Kein Timerport            */
  140. #define ERROR_NO_TIMERREQUEST    4    /* Kein Timerrequest            */
  141. #define ERROR_NO_TIMERDEVICE    5    /* Keine Timerdevice            */
  142. #define ERROR_SET_SYSTEMTIME    6    /* Kann Systemzeit nicht setzen        */
  143. #define ERROR_ZUWENIG_BITS    7    /* Zuwenig Bits gekommen        */
  144. #define ERROR_ZUVIEL_BITS    8    /* Zuviel Bits gekommen            */
  145. #define ERROR_TIME_CHECK    9    /* Time-Check falsch            */
  146. #define ERROR_TIME_PARITY    10    /* Time-Parity falsch            */
  147. #define ERROR_BITTIME        11    /* Nicht erkannte Bitzeit        */
  148. #define ERROR_KEINEZEIT        12    /* Konnte Zeit nicht erkennen        */
  149. #define ERROR_PARAMTER        13    /* Falscher Parameter in Icon        */
  150.  
  151. unsigned char *error_text[] =
  152. {
  153.     "",
  154.     "Error : Kann System-Library nicht öffnen !",
  155.     "Error : Kann Window nicht öffnen !",
  156.     "Error : Kein TimerPort !",
  157.     "Error : Kein TimerRequest !",
  158.     "Error : Keine TimerDevice !",
  159.     "Error : Kann Systemzeit nicht setzen !",
  160.     "Error : Zuwenig Bits !",
  161.     "Error : Zuviel Bits !",
  162.     "Error : Zeitcheck falsch !",
  163.     "Error : Zeitparity falsch !",
  164.     "Error : Bit nicht erkannt !",
  165.     "Error : Keine gültige Zeit gefunden !",
  166.     "Error : Falscher Parameter im Icon !"
  167. };
  168.  
  169. /* Window */
  170. struct NewWindow newwindow =
  171. {
  172.     DEFAULT_FENSTER_X,DEFAULT_FENSTER_Y,    /* Left- TopEdge    */
  173.     WINDOW_GROESSE_X,WINDOW_GROESSE_Y,    /* Width, Height    */
  174.     0,2,                    /* Detail- Blockpen    */
  175.     CLOSEWINDOW,                /* IDCMP-Flags        */
  176.     WINDOWDEPTH|WINDOWCLOSE|WINDOWDRAG,    /* Flags        */
  177.     0,                    /* FirstGadget        */
  178.     0,                    /* CheckMark        */
  179.     "AtomUhr V1.2 (C) Stefan Glükler",    /* Titel        */
  180.     0,                    /* Screen-Pointer    */
  181.     0,                    /* Bitmap-Pointer    */
  182.     0,0,                    /* MinWidth,MinHeight    */
  183.     0,0,                    /* MaxWidth,MaxHeight    */
  184.     WBENCHSCREEN                /* Window-Type        */
  185. };
  186.  
  187. /* Prototypes */
  188. unsigned char    OpenAll(void);
  189. unsigned char    WindowOpen(void);
  190. unsigned char    SetParameter(unsigned char *argument0,unsigned short arg_anz);
  191. void        CloseAll(unsigned char error_nummer);
  192. void        WriteText(unsigned char *text,unsigned short farbe);
  193. void        WriteLine(unsigned short x1,unsigned short y1,unsigned short x2,unsigned short y2,unsigned short farbe);
  194. unsigned char    SetSystem_Time(void);
  195. void        Berechnung_Time(void);
  196. unsigned char    Check_Time(void);
  197. unsigned char    ReadPort(void);
  198.  
  199. /* Globale Variablen fuer Library & Devices */
  200. unsigned char        open_device_timer    =0;
  201. struct MsgPort        *myTimerPort        =0;
  202. struct timerequest    *myTimer        =0;
  203. struct Window        *window            =0;
  204. struct GfxBase        *GfxBase        =0;
  205. struct IntuitionBase    *IntuitionBase        =0;
  206.  
  207. /* Globale Variablen fuer aktuelle Zeit */
  208. unsigned short time_sek,time_min,time_std,time_tag,time_monat,time_jahr;
  209.  
  210. /* Globale Variablen fuer Konfiguration */
  211. unsigned char  DEBUG;
  212. unsigned char  PORT;
  213. unsigned char  AUSGABE;
  214. unsigned char  PRIORITAET;
  215. unsigned short FENSTER_X;
  216. unsigned short FENSTER_Y;
  217. unsigned long  MAX_SUCHEZEIT;
  218. unsigned char  DOS_BEFEHL[100];
  219.  
  220. int main(int argc, char **argv)
  221. {
  222.  struct IntuiMessage *msg;            /* Window-Message        */
  223.  register unsigned char PulsFlag=0;        /* Flag fuer Flankenerkennung    */
  224.  register unsigned long MiliSecZaehler=0;    /* Milisekunden-Zaehler        */
  225.  register unsigned char BitBlockNummer;        /* Akt. BitBlocknummer        */
  226.  register unsigned char filter_nr=0;        /* Aktueller Filterwert        */
  227.  unsigned char  blockstatus;            /* Aktueller Status        */
  228.  unsigned long  DifHighTime;            /* Berechnete High Pulslaenge    */
  229.  unsigned long  DifLowTime;            /* Berechnete Low Pulslaenge    */
  230.  unsigned long  StartZeit=0;            /* Startzeit der Flanke        */
  231.  unsigned long  EndZeit=0;            /* Endzeit der Flanke        */
  232.  unsigned char  PortWert;                /* Portwert            */
  233.  unsigned char  error;                /* Errorcode            */
  234.  unsigned short graph_x=DEBUG_OFFSET_X;        /* Debug-Grafik-Ausgabe Kord.-X    */
  235.  unsigned char  filter_werte[3];        /* Filterwerte fuer Digitalf.    */
  236.  
  237.   /* Setzen aller Programm-Parameter */
  238.   if ((error=SetParameter(argv,argc))!=ERROR_NONE) CloseAll(error);
  239.  
  240.   /* Alles Initialiseren */
  241.   if ((error=OpenAll())!=ERROR_NONE) CloseAll(error);
  242.  
  243.   /* Setzen der eigenen Taskprioritaet */
  244.   SetTaskPri(FindTask(0),PRIORITAET);
  245.  
  246.   /* Status = Vorbereitung */
  247.   SET_BLOCKSTATUS(BLOCKSTATUS_VORBEREITUNG);
  248.  
  249.   while(blockstatus!=BLOCKSTATUS_EXIT)
  250.   {
  251.  
  252.     myTimer->tr_node.io_Command=TR_ADDREQUEST;
  253.     myTimer->tr_time.tv_secs=0;
  254.     myTimer->tr_time.tv_micro=TIMER_DELAY*1000;
  255.     DoIO(myTimer); /* Warten der Portabtastzeit */
  256.  
  257.     /* Zeitcounter erhoehen */
  258.     MiliSecZaehler+=TIMER_DELAY;
  259.  
  260.     if (window)
  261.     {
  262.       /* Abfragen der Window-Operationen */
  263.       while (msg=(struct IntuiMessage *)GetMsg(window->UserPort))
  264.       {
  265.         if (msg->Class==CLOSEWINDOW)
  266.         {
  267.           /* Status = Exit */
  268.           SET_BLOCKSTATUS(BLOCKSTATUS_EXIT);
  269.         }
  270.         ReplyMsg(msg);
  271.       }
  272.     }
  273.  
  274.     /* Suche Vorbereiten ? */
  275.     if (blockstatus==BLOCKSTATUS_VORBEREITUNG)
  276.     {
  277.  
  278.       /* Bitkodierungs-Struktur zuruecksetzen */
  279.       for (BitBlockNummer=0;BitBlockNummer<ANZAHL_BITBLOECKE;BitBlockNummer++)
  280.       {
  281.         BitCodierung[BitBlockNummer].AktBit     = 0;  /* Aktuelles Bit          */
  282.         BitCodierung[BitBlockNummer].ZahlenWert = 0;  /* Berechneter Zahlenwert */
  283.         BitCodierung[BitBlockNummer].ParityWert = 0;  /* Berechneter Paritywert */
  284.       }
  285.  
  286.       /* Filterwerte zuruecksetzen */
  287.       filter_werte[0]=filter_werte[1]=filter_werte[2]=0;
  288.  
  289.       /* Bit-Blocknummer zurueckstellen */
  290.       BitBlockNummer=0;
  291.  
  292.       /* Status = SucheStart */
  293.       SET_BLOCKSTATUS(BLOCKSTATUS_SUCHESTART);
  294.  
  295.     }
  296.  
  297.     /* Filterwerte umkopieren */
  298.     filter_werte[0]=filter_werte[1];
  299.     filter_werte[1]=filter_werte[2];
  300.     filter_werte[2]=ReadPort();
  301.  
  302.     /* Filterung */
  303.     if (filter_werte[0]==1 && filter_werte[1]==0 && filter_werte[2]==1)
  304.     {
  305.       filter_werte[1]=1;
  306.     }
  307.  
  308.     /* Aktueller Portwert setzen */
  309.     PortWert=filter_werte[0];
  310.  
  311.     /* Debug-Ausgabe */
  312.     if (DEBUG)
  313.     {
  314.  
  315.       /* Linienfarbe je nach Portwert */
  316.       if (PortWert==1) WriteLine(graph_x,DEBUG_OFFSET_Y,graph_x,DEBUG_OFFSET_Y+DEBUG_GROESSE_Y,2);
  317.       else             WriteLine(graph_x,DEBUG_OFFSET_Y,graph_x,DEBUG_OFFSET_Y+DEBUG_GROESSE_Y,0);
  318.  
  319.       /* Grafik X-Kodinate erhoehen */
  320.       graph_x++;
  321.  
  322.       /* Schreibe-Linie */
  323.       WriteLine(graph_x,DEBUG_OFFSET_Y,graph_x,DEBUG_OFFSET_Y+DEBUG_GROESSE_Y,1);
  324.  
  325.       /* Grafik-X Window-Ende erreicht */
  326.       if (graph_x>WINDOW_GROESSE_X-DEBUG_OFFSET_X-3)
  327.       {
  328.         /* Schreibe-Linie loeschen */
  329.         WriteLine(graph_x,DEBUG_OFFSET_Y,graph_x,DEBUG_OFFSET_Y+DEBUG_GROESSE_Y,0);
  330.  
  331.         /* Grafik X-Kordinate zuruecksetzen */
  332.         graph_x=DEBUG_OFFSET_X;
  333.       }
  334.  
  335.     }
  336.  
  337.     if (PulsFlag==0 && PortWert==1) /* Flag=0 und Port=HIGH -> Flankenbegin */
  338.     {
  339.  
  340.       PulsFlag=1;                   /* Flag auf Flankenbegin   */
  341.       StartZeit=MiliSecZaehler;     /* Merken der Startzeit    */
  342.       DifLowTime=StartZeit-EndZeit; /* Berechnung der Low-Zeit */
  343.  
  344.       switch(blockstatus)
  345.       {
  346.  
  347.         /****************************************************************************/
  348.         case BLOCKSTATUS_SUCHESTART:
  349.         /****************************************************************************/
  350.  
  351.           /* Synch-Start gefunden */
  352.           if (DifLowTime>TIMER_SYNCHLEN)
  353.           {
  354.  
  355.             /* Status = Zeit */
  356.             SET_BLOCKSTATUS(BLOCKSTATUS_TIME);
  357.  
  358.           }
  359.  
  360.         break;
  361.  
  362.         /****************************************************************************/
  363.         case BLOCKSTATUS_TIME:
  364.         /****************************************************************************/
  365.  
  366.           /* Synch-Start gefunden */
  367.           if (DifLowTime>TIMER_SYNCHLEN)
  368.           {
  369.  
  370.             /* Error = Zuwenig Bits */
  371.             SET_ERRORTEXT(ERROR_ZUWENIG_BITS);
  372.  
  373.             /* Status = Vorbereitung */
  374.             SET_BLOCKSTATUS(BLOCKSTATUS_VORBEREITUNG);
  375.  
  376.           }
  377.  
  378.         break;
  379.  
  380.         /****************************************************************************/
  381.         case BLOCKSTATUS_TIMEOK:
  382.         /****************************************************************************/
  383.  
  384.           /* Synch-Start nicht gefunden */
  385.           if (DifLowTime<TIMER_SYNCHLEN)
  386.           {
  387.  
  388.             /* Error = Zuviele Bits */
  389.             SET_ERRORTEXT(ERROR_ZUVIEL_BITS);
  390.  
  391.             /* Status = Vorbereitung */
  392.             SET_BLOCKSTATUS(BLOCKSTATUS_VORBEREITUNG);
  393.  
  394.             break;
  395.  
  396.           }
  397.  
  398.           /* Berechung der Zeit */
  399.           Berechnung_Time();
  400.  
  401.           if (Check_Time()==ERROR_NONE)
  402.           {
  403.  
  404.             /* Setzen der System-Zeit */
  405.             SetSystem_Time();
  406.  
  407.             /* Wurde keine Ausgabe gemacht */
  408.             if (AUSGABE==0)
  409.             {
  410.  
  411.               /* Window oeffnen */
  412.               if (WindowOpen())
  413.               {
  414.  
  415.                 /* Status = TimeOk */
  416.                 SET_BLOCKSTATUS(BLOCKSTATUS_TIMEOK);
  417.  
  418.                 /* Status 2 Sekunden anzeigen */
  419.                 Delay(100);
  420.  
  421.               }
  422.  
  423.             }
  424.  
  425.             /* Status = Exit */
  426.             SET_BLOCKSTATUS(BLOCKSTATUS_EXIT);
  427.  
  428.             break;
  429.  
  430.           }
  431.  
  432.           /* Error = Zeitkodierungsfehler */
  433.           SET_ERRORTEXT(ERROR_TIME_CHECK);
  434.  
  435.           /* Status = Vorbereitung */
  436.           SET_BLOCKSTATUS(BLOCKSTATUS_VORBEREITUNG);
  437.  
  438.         break;
  439.  
  440.       }
  441.  
  442.     }
  443.  
  444.     if (PulsFlag==1 && PortWert==0) /* Flag=1 und Port=LOW -> Flankenende */
  445.     {
  446.  
  447.       PulsFlag=0;                    /* Flag auf Flankenende     */
  448.       EndZeit=MiliSecZaehler;        /* Merken der Stopzeit      */
  449.       DifHighTime=EndZeit-StartZeit; /* Berechnung der High-Zeit */
  450.  
  451.       switch(blockstatus)
  452.       {
  453.  
  454.         /****************************************************************************/
  455.         case BLOCKSTATUS_SUCHESTART:
  456.         /****************************************************************************/
  457.  
  458.         break;
  459.  
  460.         /****************************************************************************/
  461.         case BLOCKSTATUS_TIME:
  462.         /****************************************************************************/
  463.  
  464.           if (DifHighTime>=TIMER_PULS_BIT0_MIN && DifHighTime<=TIMER_PULS_BIT0_MAX)
  465.           {
  466.             /* Codiertes 0-Bit */
  467.  
  468.           }
  469.           else if (DifHighTime>=TIMER_PULS_BIT1_MIN && DifHighTime<=TIMER_PULS_BIT1_MAX)
  470.           {
  471.             /* Codiertes 1-Bit */
  472.  
  473.             /* Berechnung des Zahlenwertes */
  474.             BitCodierung[BitBlockNummer].ZahlenWert+=1<<BitCodierung[BitBlockNummer].AktBit;
  475.  
  476.             /* Berechnung der Paritaet */
  477.             BitCodierung[BitBlockNummer].ParityWert^=1;
  478.  
  479.           }
  480.           else
  481.           {
  482.  
  483.             /* Error = Bitlaengefehler */
  484.             SET_ERRORTEXT(ERROR_BITTIME);
  485.  
  486.             /* Status = Vorbereitung */
  487.             SET_BLOCKSTATUS(BLOCKSTATUS_VORBEREITUNG);
  488.  
  489.             break;
  490.  
  491.           }
  492.  
  493.           /* Naechstes Bit */
  494.           BitCodierung[BitBlockNummer].AktBit++;
  495.  
  496.           /* Anzahl Bits des Blockes erreicht ? */
  497.           if (BitCodierung[BitBlockNummer].AktBit==BitCodierung[BitBlockNummer].AnzahlBits)
  498.           {
  499.  
  500.             /* Anzahl Bit-Bloecke erreicht ? */
  501.             if (++BitBlockNummer==ANZAHL_BITBLOECKE)
  502.             {
  503.  
  504.               /* Status = TimeOk */
  505.               SET_BLOCKSTATUS(BLOCKSTATUS_TIMEOK);
  506.  
  507.             }
  508.  
  509.           }
  510.  
  511.         break;
  512.  
  513.         /****************************************************************************/
  514.         case BLOCKSTATUS_TIMEOK:
  515.         /****************************************************************************/
  516.  
  517.         break;
  518.  
  519.       }
  520.  
  521.     }
  522.  
  523.     /* Suchezeit abgelaufen */
  524.     if (MiliSecZaehler>MAX_SUCHEZEIT*1000)
  525.     {
  526.  
  527.       /* Error = Suchezeit abgelaufen */
  528.       SET_ERRORTEXT(ERROR_KEINEZEIT);
  529.       /* Status = Exit */
  530.       SET_BLOCKSTATUS(BLOCKSTATUS_EXIT);
  531.  
  532.     }
  533.  
  534.   }
  535.  
  536.   CloseAll(ERROR_NONE);
  537.  
  538.   return(0);
  539. }
  540.  
  541. unsigned char ReadPort(void)
  542. {
  543.  extern volatile struct Custom custom;
  544.  extern volatile struct CIA ciaa;
  545.  extern volatile struct CIA ciab;
  546.  
  547.   if (PORT==2) return(((~ciab.ciapra)>>5)&0x01);
  548.   if (PORT==1) return((ciaa.ciapra>>7)&0x01);
  549.   return(((~custom.joy1dat)>>8)&0x01);
  550. }
  551.  
  552. void Berechnung_Time(void)
  553. {
  554.   time_sek   = 0;
  555.   time_min   = BitCodierung[BITBLOCK_MIN_LOW  ].ZahlenWert+BitCodierung[BITBLOCK_MIN_HIGH  ].ZahlenWert*10;
  556.   time_std   = BitCodierung[BITBLOCK_STD_LOW  ].ZahlenWert+BitCodierung[BITBLOCK_STD_HIGH  ].ZahlenWert*10;
  557.   time_tag   = BitCodierung[BITBLOCK_TAG_LOW  ].ZahlenWert+BitCodierung[BITBLOCK_TAG_HIGH  ].ZahlenWert*10;
  558.   time_monat = BitCodierung[BITBLOCK_MONAT_LOW].ZahlenWert+BitCodierung[BITBLOCK_MONAT_HIGH].ZahlenWert*10;
  559.   time_jahr  = BitCodierung[BITBLOCK_JAHR_LOW ].ZahlenWert+BitCodierung[BITBLOCK_JAHR_HIGH ].ZahlenWert*10;
  560. }
  561.  
  562. unsigned char Check_Time(void)
  563. {
  564.  register unsigned char ParityTotal;
  565.  
  566.   /* Parity-1-Check */
  567.   ParityTotal=(BitCodierung[BITBLOCK_MIN_LOW ].ParityWert
  568.               +BitCodierung[BITBLOCK_MIN_HIGH].ParityWert)&1;
  569.   if (BitCodierung[BITBLOCK_PARITY_1].ZahlenWert!=ParityTotal) return(ERROR_TIME_PARITY);
  570.  
  571.   /* Parity-2-Check */
  572.   ParityTotal=(BitCodierung[BITBLOCK_STD_LOW ].ParityWert
  573.               +BitCodierung[BITBLOCK_STD_HIGH].ParityWert)&1;
  574.   if (BitCodierung[BITBLOCK_PARITY_2].ZahlenWert!=ParityTotal) return(ERROR_TIME_PARITY);
  575.  
  576.   /* Parity-3-Check */
  577.   ParityTotal=(BitCodierung[BITBLOCK_TAG_LOW   ].ParityWert
  578.               +BitCodierung[BITBLOCK_TAG_HIGH  ].ParityWert
  579.               +BitCodierung[BITBLOCK_WOCHENTAG ].ParityWert
  580.               +BitCodierung[BITBLOCK_MONAT_LOW ].ParityWert
  581.               +BitCodierung[BITBLOCK_MONAT_HIGH].ParityWert
  582.               +BitCodierung[BITBLOCK_JAHR_LOW  ].ParityWert
  583.               +BitCodierung[BITBLOCK_JAHR_HIGH ].ParityWert)&1;
  584.   if (BitCodierung[BITBLOCK_PARITY_3].ZahlenWert!=ParityTotal) return(ERROR_TIME_PARITY);
  585.  
  586.   /* Grenzen-Check */
  587.   if (time_sek  >59) return(ERROR_TIME_CHECK);
  588.   if (time_min  >59) return(ERROR_TIME_CHECK);
  589.   if (time_std  >23) return(ERROR_TIME_CHECK);
  590.   if (time_tag  >31) return(ERROR_TIME_CHECK);
  591.   if (time_monat>12) return(ERROR_TIME_CHECK);
  592.   if (time_jahr >99) return(ERROR_TIME_CHECK);
  593.   if (time_jahr <95) return(ERROR_TIME_CHECK);
  594.  
  595.   return(ERROR_NONE);
  596. }
  597.  
  598. unsigned char SetSystem_Time(void)
  599. {
  600.  BPTR commandooutput;
  601.  unsigned char doscomando[50];
  602.  
  603.   sprintf(doscomando,"date %02d-%02d-%02d %02d:%02d:%02d",time_tag,time_monat,time_jahr,time_std,time_min,time_sek);
  604.   if ((commandooutput=Open("T:AtomUhr.tmp",MODE_NEWFILE))==0) return(ERROR_SET_SYSTEMTIME);
  605.   if (Execute(doscomando,0,commandooutput)==0)
  606.   {
  607.     Close(commandooutput);
  608.     return(ERROR_SET_SYSTEMTIME);
  609.   }
  610.   if (strlen(DOS_BEFEHL)>0)
  611.   {
  612.     if (Execute(DOS_BEFEHL,0,commandooutput)==0)
  613.     {
  614.       Close(commandooutput);
  615.       return(ERROR_SET_SYSTEMTIME);
  616.     }
  617.   }
  618.   Close(commandooutput);
  619.  
  620.   return(ERROR_NONE);
  621. }
  622.  
  623. void WriteText(unsigned char *text,unsigned short farbe)
  624. {
  625.  unsigned char outtext[50];
  626.  
  627.   if (window)
  628.   {
  629.     sprintf(outtext,"%-37.37s",text);
  630.     SetAPen(window->RPort,farbe);
  631.     Move(window->RPort,8,18);
  632.     Text(window->RPort,outtext,strlen(outtext));
  633.   }
  634. }
  635.  
  636. void WriteLine(unsigned short x1,unsigned short y1,unsigned short x2,unsigned short y2,unsigned short farbe)
  637. {
  638.   if (window)
  639.   {
  640.     SetAPen(window->RPort,farbe);
  641.     Move(window->RPort,x1,y1);
  642.     Draw(window->RPort,x2,y2);
  643.   }
  644. }
  645.  
  646. unsigned char OpenAll(void)
  647. {
  648.   if ((IntuitionBase=(struct IntuitionBase *)OpenLibrary("intuition.library",0))==0) return(ERROR_NO_LIBRARYS);
  649.   if ((GfxBase=(struct GfxBase *)OpenLibrary("graphics.library",0))==0) return(ERROR_NO_LIBRARYS);
  650.  
  651.   if ((myTimerPort=(struct MsgPort *)CreatePort("AtomUhr.TimerPort",0))==0) return(ERROR_NO_TIMERPORT);
  652.   if ((myTimer=(struct timerequest *)CreateExtIO(myTimerPort,sizeof(struct timerequest)))==0) return(ERROR_NO_TIMERREQUEST);
  653.   if (OpenDevice(TIMERNAME,UNIT_MICROHZ,myTimer,0)!=0) return(ERROR_NO_TIMERDEVICE);
  654.   open_device_timer=1;
  655.  
  656.   if (AUSGABE) if (WindowOpen()) return(ERROR_NO_WINDOW);
  657.  
  658.   return(ERROR_NONE);
  659. }
  660.  
  661. unsigned char WindowOpen(void)
  662. {
  663.   if (DEBUG)
  664.   {
  665.     newwindow.Height=DEBUG_WINDOW_GROESSE_Y;
  666.   }
  667.   else
  668.   {
  669.     newwindow.Height=WINDOW_GROESSE_Y;
  670.   }
  671.   newwindow.LeftEdge = FENSTER_X;
  672.   newwindow.TopEdge  = FENSTER_Y;
  673.   if ((window=OpenWindow(&newwindow))==0) return(1);
  674.   SetBPen(window->RPort,0);
  675.   return(0);
  676. }
  677.  
  678. void CloseAll(unsigned char error_nummer)
  679. {
  680.   if (error_nummer)
  681.   {
  682.     if (error_nummer<=ERROR_NO_WINDOW)
  683.     {
  684.       printf("\n%s\n\n",error_text[error_nummer]);
  685.     }
  686.     else
  687.     {
  688.       WriteText(error_text[error_nummer],2);
  689.     }
  690.   }
  691.  
  692.   Delay(100);
  693.  
  694.   if (window)            CloseWindow(window);
  695.   if (IntuitionBase)        CloseLibrary(IntuitionBase);
  696.   if (GfxBase)            CloseLibrary(GfxBase);
  697.   if (open_device_timer)    CloseDevice(myTimer);
  698.   if (myTimer)            DeleteExtIO(myTimer);
  699.   if (myTimerPort)        DeletePort(myTimerPort);
  700.  
  701.   exit(0);
  702. }
  703.  
  704. unsigned char SetParameter(unsigned char *argument0,unsigned short arg_anz)
  705. {
  706.  unsigned char PrgName[120];
  707.  struct DiskObject *myDiskObject;
  708.  struct IconBase *IconBase;
  709.  struct WBStartup *Wbs;
  710.  unsigned char *text_zeiger;
  711.  
  712.   DEBUG         = DEFAULT_DEBUG;
  713.   PRIORITAET    = DEFAULT_PRIORITAET;
  714.   PORT        = DEFAULT_PORT;
  715.   AUSGABE       = DEFAULT_AUSGABE;
  716.   FENSTER_X     = DEFAULT_FENSTER_X;
  717.   FENSTER_Y     = DEFAULT_FENSTER_Y;
  718.   MAX_SUCHEZEIT = DEFAULT_MAX_SUCHEZEIT;
  719.   strcpy(DOS_BEFEHL,DEFAULT_DOS_BEFEHL);
  720.  
  721.   Wbs=(struct WBStartup *)argument0;
  722.   if (arg_anz==0 && Wbs && Wbs->sm_NumArgs>0 && Wbs->sm_ArgList[Wbs->sm_NumArgs-1].wa_Lock)
  723.   {
  724.     strcpy(PrgName,"");
  725.     NameFromLock(Wbs->sm_ArgList[Wbs->sm_NumArgs-1].wa_Lock,PrgName,sizeof(PrgName));
  726.     if (strlen(PrgName)>0 && PrgName[strlen(PrgName)-1]!=':' && PrgName[strlen(PrgName)-1]!='/') strcat(PrgName,"/");
  727.     strcat(PrgName,Wbs->sm_ArgList[Wbs->sm_NumArgs-1].wa_Name);
  728.   }
  729.   else
  730.   {
  731.     strcpy(PrgName,"");
  732.     GetProgramName(PrgName,sizeof(PrgName));
  733.   }
  734.  
  735.   if (strlen(PrgName))
  736.   {
  737.  
  738.     if ((IconBase=(struct IconBase *)OpenLibrary("icon.library",0))==0) return(ERROR_NO_LIBRARYS);
  739.  
  740.     if (myDiskObject=GetDiskObject(PrgName))
  741.     {
  742.       if ((text_zeiger=FindToolType(myDiskObject->do_ToolTypes,"PRIORITAET"))!=0)    PRIORITAET    = atoi(text_zeiger);
  743.       if ((text_zeiger=FindToolType(myDiskObject->do_ToolTypes,"FENSTER_X"))!=0)     FENSTER_X     = atoi(text_zeiger);
  744.       if ((text_zeiger=FindToolType(myDiskObject->do_ToolTypes,"FENSTER_Y"))!=0)     FENSTER_Y     = atoi(text_zeiger);
  745.       if ((text_zeiger=FindToolType(myDiskObject->do_ToolTypes,"MAX_SUCHEZEIT"))!=0) MAX_SUCHEZEIT = atoi(text_zeiger);
  746.       if ((text_zeiger=FindToolType(myDiskObject->do_ToolTypes,"DOS_BEFEHL"))!=0 )   strcpy(DOS_BEFEHL,text_zeiger);
  747.       if ((text_zeiger=FindToolType(myDiskObject->do_ToolTypes,"AUSGABE"))!=0)
  748.       {
  749.              if (strcmp(text_zeiger,"EIN")==0) AUSGABE=1;
  750.         else if (strcmp(text_zeiger,"AUS")==0) AUSGABE=0;
  751.         else return(ERROR_PARAMTER);
  752.       }
  753.       if ((text_zeiger=FindToolType(myDiskObject->do_ToolTypes,"DEBUG"))!=0)
  754.       {
  755.              if (strcmp(text_zeiger,"EIN")==0) AUSGABE=DEBUG=1;
  756.         else if (strcmp(text_zeiger,"AUS")==0) DEBUG=0;
  757.         else return(ERROR_PARAMTER);
  758.       }
  759.       if ((text_zeiger=FindToolType(myDiskObject->do_ToolTypes,"PORT"))!=0)
  760.       {
  761.              if (strcmp(text_zeiger,"JOY_PIN1")==0) PORT=0;
  762.         else if (strcmp(text_zeiger,"JOY_PIN6")==0) PORT=1;
  763.         else if (strcmp(text_zeiger,"SER_PIN8")==0) PORT=2;
  764.         else return(ERROR_PARAMTER);
  765.       }
  766.  
  767.       FreeDiskObject(myDiskObject);
  768.  
  769.     }
  770.  
  771.     CloseLibrary(IconBase);
  772.  
  773.   }
  774.  
  775.   return(ERROR_NONE);
  776. }
  777.  
  778.